// 获取全局应用实例
const app = getApp()
// 初始化云数据库
const db = wx.cloud.database()
// 获取数据库指令
const _ = db.command

Page({
  data: {
    currentTab: 'all', // 'all' 或 'followup'
    students: [],      // 学生列表数据
    interventionRecords: [], // 干预记录列表
    showDetailModal: false,  // 是否显示详情模态框
    showAddModal: false,     // 是否显示添加模态框
    currentStudent: null,    // 当前选中的学生
    formData: {
      interactionType: 'talk', // 交互类型默认为谈话
      content: '',             // 内容
      status: '',              // 状态
      attachments: [],         // 附件列表
      nextDate: ''             // 下次日期
    },
    today: '',                // 今天的日期
    classList: [],            // 班级列表
    currentClass: 'all',      // 当前选择的班级，'all'表示全部
    searchText: '',           // 搜索文本
    dateFilter: '',           // 日期筛选
    loading: true,            // 加载状态
    currentBack: null,        // 当前查看的回访记录
    backRecords: [],          // 回访记录列表
    // 心理状态选项及映射
    mentalStatusOptions: ['良好', '一般', '较差', '严重'], 
    mentalStatusMapping: {
      '良好': 'good',
      '一般': 'normal',
      '较差': 'poor',
      '严重': 'severe'
    },
    // 回访表单数据
    formData: {
      backContent: '',    // 回访内容
      backTime: '',       // 回访时间
      mentalStatus: '',   // 心理状态评估
      suggestion: '',     // 建议
      nextBackTime: '',   // 下次回访时间
      finished: false     // 是否完成
    },
    systemDefaultAvatar: null // 系统默认头像
  },

  // 学生列表头像加载失败处理 - 移到最前面确保正确注册
  onImageError: function(e) {
    console.log('头像加载失败', e)
    const index = e.currentTarget.dataset.index
    // 设置为空字符串，依靠CSS中的白色背景显示
    this.setData({
      [`students[${index}].avatarUrl`]: ''
    })
  },

  // 模态框头像加载失败处理 - 移到最前面确保正确注册
  onModalImageError: function() {
    console.log('模态框头像加载失败')
    // 设置为空字符串，依靠CSS中的白色背景显示
    this.setData({
      'currentStudent.avatarUrl': ''
    })
  },

  // 返回上一页
  goBack: function() {
    wx.navigateBack({
      delta: 1
    });
  },

  // 页面加载时初始化数据
  onLoad: function (options) {
    // 设置当前日期和回访时间默认值
    this.setData({
      today: this.formatDate(new Date()),
      'formData.backTime': this.formatDate(new Date())
    })
    this.loadClassList() // 先加载班级列表
    this.fetchStudentsWithConsultation() // 获取有咨询记录的学生
  },

  // 下拉刷新处理函数
  onPullDownRefresh: function () {
    this.fetchStudentsWithConsultation().then(() => {
      wx.stopPullDownRefresh()
    })
  },

  // 格式化日期为 YYYY-MM-DD
  formatDate: function (date) {
    // 如果传入的是字符串，先转换为Date对象
    if (typeof date === 'string') {
      date = new Date(date);
    }
    
    // 确保date是有效的Date对象
    if (!(date instanceof Date) || isNaN(date)) {
      console.error('无效的日期:', date);
      return '无效日期';
    }
    
    // 提取年月日并格式化
    const year = date.getFullYear()
    const month = (date.getMonth() + 1).toString().padStart(2, '0')
    const day = date.getDate().toString().padStart(2, '0')
    return `${year}-${month}-${day}`
  },

  // 加载班级列表
  loadClassList: function() {
    const userInfo = wx.getStorageSync('userInfo')
    // 未登录时直接获取学生列表
    if (!userInfo) {
      this.fetchStudentsWithConsultation()
      return
    }
    
    // 直接调用获取学生列表，不等待班级列表加载
    // 这样即使classes集合不存在也不会影响主要功能
    this.fetchStudentsWithConsultation()
    
    // 从users集合中提取班级信息，而不是使用classes集合
    wx.cloud.database().collection('users').field({
      class: true,
      classes: true
    }).get().then(res => {
      console.log('成功获取用户数据', res.data)
      
      // 提取所有班级信息（可能在class或classes字段中）
      const classSet = new Set()
      
      // 遍历所有用户数据，收集班级信息
      res.data.forEach(user => {
        // 处理单个class字段
        if (user.class) {
          classSet.add(user.class)
        }
        
        // 处理classes数组字段
        if (user.classes && Array.isArray(user.classes)) {
          user.classes.forEach(cls => {
            if (cls) classSet.add(cls)
          })
        }
      })
      
      // 转换为数组并排序
      const classList = Array.from(classSet).sort()
      console.log('提取的班级列表', classList)
      
      // 将班级列表转换为所需的数据格式
      const formattedClassList = classList.map(className => ({
        id: className,
        name: className
      }))
      
      this.setData({
        classList: formattedClassList
      })
    }).catch(err => {
      console.error('获取用户数据失败', err)
      // 不再调用fetchStudentsWithConsultation，因为我们已经在上面调用过了
    })
  },

  // 切换班级筛选
  switchClass: function(e) {
    const classId = e.currentTarget.dataset.id
    this.setData({
      currentClass: classId
    })
    this.fetchStudentsWithConsultation()
  },

  // 获取有咨询记录的学生列表
  fetchStudentsWithConsultation: async function () {
    // 显示加载提示
    wx.showLoading({
      title: '加载中',
    })

    try {
      // 定义默认头像
      const defaultAvatarUrl = '/assets/icons/function.png'
      
      // 尝试从数据库获取系统配置中的默认头像
      let systemDefaultAvatar = defaultAvatarUrl
      try {
        const configRes = await db.collection('system_config').where({configKey: 'defaultAvatar'}).get()
        if (configRes.data && configRes.data.length > 0 && configRes.data[0].configValue) {
          systemDefaultAvatar = configRes.data[0].configValue
          console.log('从数据库获取默认头像:', systemDefaultAvatar)
        }
      } catch (err) {
        console.log('获取默认头像配置失败:', err)
      }
      
      // 先尝试获取所有咨询记录
      let consultationData = []
      try {
        const consultationRes = await db.collection('consultation_records').get()
        consultationData = consultationRes.data
        console.log('获取到咨询记录:', consultationData.length, consultationData)
      } catch (err) {
        // 处理咨询记录获取失败的情况
        console.error('获取咨询记录失败:', err)
        if (err.errCode === -502005) {
          wx.showToast({
            title: '请先创建咨询记录',
            icon: 'none'
          })
        }
        wx.hideLoading()
        this.setData({ loading: false })
        return
      }
      
      // 如果没有咨询记录，直接结束
      if (consultationData.length === 0) {
        wx.hideLoading()
        this.setData({
          students: [],
          loading: false
        })
        return
      }

      // 提取所有记录的用户名
      const usernames = [...new Set(consultationData.map(item => {
        // 使用用户名作为唯一标识符
        return item.username
      }))]
      
      // 尝试获取这些用户的信息（包括头像）
      let userInfo = {}
      try {
        // 首先通过用户名查询所有用户数据，建立用户名到用户数据的映射
        const usernameToUserMap = {}
        try {
          const allUsersRes = await db.collection('users').get()
          const allUsers = allUsersRes.data || []
          
          // 建立用户名到用户数据的映射
          allUsers.forEach(user => {
            if (user.username) {
              usernameToUserMap[user.username] = user
            }
          })
          
          console.log('获取到用户名映射:', usernameToUserMap)
        } catch (err) {
          console.error('获取所有用户信息失败:', err)
        }
        
        // 遍历每个用户名，获取用户信息
        for (const username of usernames) {
          try {
            // 跳过空用户名
            if (!username) continue;
            
            // 尝试通过用户名查询
            const userRes = await db.collection('users')
              .where({ username: username })
              .get()
            
            // 保存用户信息到映射对象中
            if (userRes.data && userRes.data.length > 0) {
              userInfo[username] = userRes.data[0]
            }
          } catch (err) {
            console.log(`通过用户名查询用户失败: ${username}`, err)
          }
        }
        console.log('获取到的用户信息:', userInfo)
        
        // 将用户名映射合并到用户信息中
        userInfo.byUsername = usernameToUserMap
      } catch (err) {
        console.error('获取用户信息失败:', err)
      }
      
      // 直接基于咨询记录创建学生列表
      let studentsFromConsultations = []
      
      // 遍历所有咨询记录，构建学生列表
      for (const record of consultationData) {
        // 跳过没有username或username为教师或管理员的记录
        if (!record.username || record.username === 'teacher' || record.username === 'admin') {
          continue
        }
        
        // 获取用户名
        const username = record.username
        
        // 查找是否已添加该学生
        const existingStudentIndex = studentsFromConsultations.findIndex(
          s => s.username === username
        )
        
        if (existingStudentIndex >= 0) {
          // 如果已存在，更新最新的咨询记录
          const existingStudent = studentsFromConsultations[existingStudentIndex]
          const existingRecordTime = existingStudent.latestRecord ? 
            new Date(existingStudent.latestRecord.createTime || existingStudent.latestRecord.updateTime) : 
            new Date(0)
          
          // 比较记录时间，保留最新的记录
          const newRecordTime = new Date(record.createTime || record.updateTime)
          if (newRecordTime > existingRecordTime) {
            existingStudent.latestRecord = record
          }
        } else {
          // 获取该学生的完整信息（如果有）
          const user = userInfo[username] || {}
          
          // 尝试通过用户名获取更详细的用户信息
          let userByUsername = null
          if (username && userInfo.byUsername && userInfo.byUsername[username]) {
            userByUsername = userInfo.byUsername[username]
            console.log(`通过用户名 ${username} 找到用户信息:`, userByUsername)
          } else {
            console.log(`未通过用户名 ${username} 找到用户信息`)
          }
          
          // 优先使用通过用户名查找到的用户信息
          const mergedUser = userByUsername || user
          console.log(`学生 ${username} 最终使用的用户信息:`, mergedUser)
          
          // 检查头像URL是否为临时文件或无效URL
          let avatarUrl = mergedUser.avatarUrl || null
          console.log(`学生 ${username} 原始头像URL:`, avatarUrl)
          
          // 处理无效头像URL的情况
          if (!avatarUrl || 
              avatarUrl === '' || 
              avatarUrl.includes('wxfile://') ||
              avatarUrl.startsWith('data:image')) {
            console.log(`学生 ${username} 的头像URL无效或是临时文件，使用默认图标`)
            avatarUrl = systemDefaultAvatar
          }
          
          // 处理云存储路径及相对路径
          if (avatarUrl && avatarUrl.startsWith('cloud://')) {
            // 保持原样，云存储路径会自动解析
            console.log(`学生 ${username} 的头像是云存储路径，保持原样:`, avatarUrl)
          } else if (avatarUrl && !avatarUrl.startsWith('/') && !avatarUrl.startsWith('http')) {
            // 如果不是绝对路径也不是URL，添加斜杠前缀
            avatarUrl = '/' + avatarUrl
            console.log(`学生 ${username} 的头像路径已添加前缀:`, avatarUrl)
          }
          
          console.log(`学生 ${username} 最终使用的头像URL:`, avatarUrl)
          
          // 添加新学生到列表中
          studentsFromConsultations.push({
            _id: username,
            username: username,
            name: mergedUser.username || username,
            studentId: mergedUser.studentId || record.studentId || '未知',
            class: mergedUser.class || record.location || record.class || '未知班级',
            role: 'student',
            avatarUrl: avatarUrl, // 处理后的头像URL
            latestRecord: record,
            isTemporary: !mergedUser.avatarUrl // 如果没有头像，则视为临时用户
          })
        }
      }
      
      console.log('创建的学生列表:', studentsFromConsultations)
      
      // 为每个学生添加回访记录
      const studentWithBack = await Promise.all(studentsFromConsultations.map(async (user) => {
        // 尝试查询学生的回访记录，不限制条数，获取所有回访记录
        let backRecords = []
        try {
          // 从数据库查询回访记录
          const backResult = await db.collection('consultation_back')
            .where({
              username: user.username // 使用用户名查询
            })
            .orderBy('backTime', 'desc')
            .get()
          
          if (backResult.data.length > 0) {
            backRecords = backResult.data
          }
        } catch (err) {
          // 忽略错误，通常是因为集合不存在
          console.log(`用户 ${user.username} 没有回访记录或集合不存在`)
        }
        
        // 获取最新回访记录和最远的下次回访时间
        let latestBackRecord = backRecords.length > 0 ? backRecords[0] : null
        let farthestNextBackTime = null
        
        // 查找最远的下次回访时间
        if (backRecords.length > 0) {
          for (const record of backRecords) {
            if (record.nextBackTime) {
              let nextBackDate;
              
              try {
                // 处理不同类型的日期格式
                if (record.nextBackTime instanceof Date) {
                  nextBackDate = record.nextBackTime;
                } else if (typeof record.nextBackTime === 'object' && record.nextBackTime.$date) {
                  // 处理服务器日期格式 ($date)
                  nextBackDate = new Date(record.nextBackTime.$date);
                } else {
                  // 尝试解析字符串日期
                  nextBackDate = new Date(record.nextBackTime);
                }
                
                // 验证日期是否有效并更新最远回访时间
                if (!isNaN(nextBackDate.getTime())) {
                  console.log("处理下次回访时间:", record.nextBackTime, "->", nextBackDate);
                  if (!farthestNextBackTime || nextBackDate > farthestNextBackTime) {
                    farthestNextBackTime = nextBackDate;
                  }
                } else {
                  console.error("无效的下次回访日期:", record.nextBackTime);
                }
              } catch (error) {
                console.error("处理下次回访日期时出错:", error, record.nextBackTime);
              }
            }
          }
        }
        
        // 获取最新咨询记录
        const latestConsultation = user.latestRecord
        
        // 确保有username值
        const userUsername = user.username || '未知'

        // 构建学生信息对象
        const studentInfo = {
          _id: userUsername,
          name: userUsername,
          studentId: user.studentId || latestConsultation?.studentId || '未知',
          class: user.class || latestConsultation?.location || latestConsultation?.class || '未知班级',
          avatarUrl: user.avatarUrl || systemDefaultAvatar, // 优先使用用户的头像URL
          lastConsultation: '无记录',
          lastBack: '未回访',
          nextBack: '',
          needsFollowUp: false,
          consultationRecord: latestConsultation,
          backRecord: latestBackRecord,
          isTemporary: user.isTemporary
        }
        
        // 设置最近咨询时间
        if (latestConsultation) {
          try {
            const consultTime = latestConsultation.createTime || latestConsultation.updateTime;
            studentInfo.lastConsultation = this.formatDate(new Date(consultTime));
          } catch (e) {
            console.error('处理咨询时间出错:', e);
          }
        }
        
        // 设置最近回访时间
        if (latestBackRecord && latestBackRecord.backTime) {
          try {
            let backTime = latestBackRecord.backTime;
            // 根据不同日期格式进行处理
            if (backTime instanceof Date) {
              studentInfo.lastBack = this.formatDate(backTime);
            } else if (typeof backTime === 'object' && backTime.$date) {
              studentInfo.lastBack = this.formatDate(new Date(backTime.$date));
            } else {
              studentInfo.lastBack = this.formatDate(new Date(backTime));
            }
          } catch (e) {
            console.error('处理回访时间出错:', e);
          }
        }
        
        // 设置下次回访时间
        if (farthestNextBackTime) {
          try {
            studentInfo.nextBack = this.formatDate(farthestNextBackTime);
            console.log("最远回访时间:", studentInfo.nextBack);
          } catch (e) {
            console.error('处理下次回访时间出错:', e);
          }
        }
        
        // 设置是否需要回访
        studentInfo.needsFollowUp = this.checkNeedsFollowUp(latestBackRecord, latestConsultation, farthestNextBackTime);

        return studentInfo
      }))

      // 按照回访优先级排序
      studentWithBack.sort((a, b) => {
        // 首先按照是否需要回访排序
        if (a.needsFollowUp && !b.needsFollowUp) return -1
        if (!a.needsFollowUp && b.needsFollowUp) return 1
        
        // 其次按照最近咨询时间排序
        const aDate = a.consultationRecord ? new Date(a.consultationRecord.createTime || a.consultationRecord.updateTime) : new Date(0)
        const bDate = b.consultationRecord ? new Date(b.consultationRecord.createTime || b.consultationRecord.updateTime) : new Date(0)
        return bDate - aDate  // 降序排列
      })

      // 更新页面数据并关闭加载提示
      this.setData({
        students: studentWithBack,
        loading: false,
        systemDefaultAvatar: systemDefaultAvatar
      })
      
      wx.hideLoading()
    } catch (error) {
      // 错误处理
      console.error('获取学生列表失败:', error)
      wx.hideLoading()
      wx.showToast({
        title: '获取数据失败',
        icon: 'none'
      })
      this.setData({ loading: false })
    }
  },

  // 检查是否需要回访
  checkNeedsFollowUp: function(backRecord, consultationRecord, farthestNextBackTime) {
    if (!consultationRecord) return false
    
    // 获取今天的日期（仅日期部分）
    const today = new Date()
    today.setHours(0, 0, 0, 0)
    
    // 如果没有回访记录，则需要回访
    if (!backRecord) return true
    
    // 如果有回访记录但咨询记录更新，则需要回访
    let backTime;
    // 处理不同类型的回访时间格式
    if (backRecord.backTime instanceof Date) {
      backTime = backRecord.backTime;
    } else {
      try {
        backTime = new Date(backRecord.backTime);
      } catch (e) {
        console.error('无效的回访时间:', backRecord.backTime);
        return true;
      }
    }
    
    // 处理不同类型的咨询时间格式
    let consultationTime;
    if (consultationRecord.createTime instanceof Date) {
      consultationTime = consultationRecord.createTime;
    } else {
      try {
        consultationTime = new Date(consultationRecord.createTime || consultationRecord.updateTime);
      } catch (e) {
        console.error('无效的咨询时间:', consultationRecord.createTime);
        return false;
      }
    }
    
    // 如果咨询时间晚于回访时间，需要回访
    if (consultationTime > backTime) return true
    
    // 如果设置了下次回访时间且已到期，则需要回访
    if (farthestNextBackTime) {
      const nextBackTimeCopy = new Date(farthestNextBackTime.getTime());
      nextBackTimeCopy.setHours(0, 0, 0, 0);
      if (today >= nextBackTimeCopy) return true;
    }
    
    return false
  },

  // 搜索输入处理
  onSearchInput: function (e) {
    const searchText = e.detail.value.trim()
    this.setData({ searchText })
    this.filterStudents()
  },

  // 日期筛选变化处理
  onDateFilterChange: function (e) {
    this.setData({ dateFilter: e.detail.value })
    this.filterStudents()
  },

  // 根据搜索条件筛选学生
  filterStudents: function() {
    // 如果没有筛选条件，重新获取全部学生
    if (!this.data.searchText && !this.data.dateFilter) {
      this.fetchStudentsWithConsultation()
      return
    }
    
    // 克隆原始学生列表
    let filteredStudents = [...this.data.students]
    
    // 应用搜索文本过滤
    if (this.data.searchText) {
      const searchText = this.data.searchText.toLowerCase()
      filteredStudents = filteredStudents.filter(student => 
        student.name.toLowerCase().includes(searchText) ||
        student.studentId.toLowerCase().includes(searchText) ||
        (student.class && student.class.toLowerCase().includes(searchText))
      )
    }
    
    // 应用日期过滤
    if (this.data.dateFilter) {
      filteredStudents = filteredStudents.filter(student => {
        // 如果过滤的是最近咨询日期
        if (student.lastConsultation === this.data.dateFilter) return true
        // 如果过滤的是最近回访日期
        if (student.lastBack === this.data.dateFilter) return true
        // 如果过滤的是下次回访日期
        if (student.nextBack === this.data.dateFilter) return true
        return false
      })
    }
    
    // 更新显示的学生列表
    this.setData({ students: filteredStudents })
  },

  // 点击学生卡片，查看回访记录
  onStudentTap: function(e) {
    const studentId = e.currentTarget.dataset.id
    // 使用ID查找学生
    const student = this.data.students.find(item => item._id === studentId)
    if (student) {
      this.setData({ currentStudent: student })
      // 使用学生名称查询回访记录
      this.fetchBackRecords(student.username)
    }
  },

  // 获取学生的回访记录
  fetchBackRecords: function(studentId) {
    wx.showLoading({ title: '加载中' })
    
    // 直接尝试获取记录，如果集合不存在则会返回错误
    db.collection('consultation_back')
      .where({ username: this.data.currentStudent.username }) // 使用用户名查询
      .orderBy('backTime', 'desc')
      .get()
      .then(res => {
        console.log('获取到回访记录:', res.data);
        // 处理记录数据，格式化日期
        const records = (res.data || []).map(record => {
          // 确保日期格式正确
          let backTime = record.backTime;
          let nextBackTime = record.nextBackTime;
          
          // 处理回访时间格式
          if (backTime && typeof backTime === 'object' && backTime.constructor) {
            if (backTime.constructor.name === 'Date' || backTime instanceof Date) {
              backTime = backTime.toISOString();
            } else if (backTime.type === 'server' && backTime.$date) {
              // 处理服务器日期格式
              backTime = new Date(backTime.$date).toISOString();
            }
          }
          
          // 处理下次回访时间格式
          if (nextBackTime && typeof nextBackTime === 'object' && nextBackTime.constructor) {
            if (nextBackTime.constructor.name === 'Date' || nextBackTime instanceof Date) {
              nextBackTime = nextBackTime.toISOString();
            } else if (nextBackTime.type === 'server' && nextBackTime.$date) {
              // 处理服务器日期格式
              nextBackTime = new Date(nextBackTime.$date).toISOString();
            }
          }

          // 初始化格式化后的日期值
          let backTimeFormatted = '未知';
          let nextBackTimeFormatted = '未设置';

          // 格式化回访时间
          try {
            backTimeFormatted = backTime ? this.formatDate(new Date(backTime)) : '未知';
          } catch (e) {
            console.error('格式化回访时间失败:', backTime, e);
          }

          // 格式化下次回访时间
          try {
            nextBackTimeFormatted = nextBackTime ? this.formatDate(new Date(nextBackTime)) : '未设置';
          } catch (e) {
            console.error('格式化下次回访时间失败:', nextBackTime, e);
          }
          
          // 返回带格式化日期的记录对象
          return {
            ...record,
            backTimeFormatted,
            nextBackTimeFormatted
          };
        });
        
        // 更新页面数据并显示详情模态框
        this.setData({
          backRecords: records,
          showDetailModal: true
        });
        wx.hideLoading();
      })
      .catch(err => {
        console.error('获取回访记录失败:', err)
        // 即使获取失败也显示详情对话框，只是没有记录
        this.setData({
          backRecords: [],
          showDetailModal: true
        })
        wx.hideLoading()
        
        // 处理特定错误码
        if (err.errCode === -502005) {
          console.log('consultation_back集合不存在，这是正常的，首次使用时会创建')
        } else {
          wx.showToast({
            title: '暂无回访记录',
            icon: 'none'
          })
        }
      })
  },

  // 关闭详情对话框
  closeDetailModal: function() {
    this.setData({
      showDetailModal: false,
      currentStudent: null,
      backRecords: []
    })
  },

  // 添加回访记录按钮处理
  addBackRecord: function() {
    // 获取今天的日期作为默认回访时间
    const today = this.formatDate(new Date())
    // 初始化表单数据并显示添加模态框
    this.setData({
      showAddModal: true,
      formData: {
        backContent: '',
        backTime: today,
        mentalStatus: '',
        suggestion: '',
        nextBackTime: '',
        finished: false
      }
    })
  },

  // 关闭添加回访对话框
  closeAddModal: function() {
    this.setData({ showAddModal: false })
  },

  // 表单字段输入处理
  onBackContentInput: function(e) {
    this.setData({ 'formData.backContent': e.detail.value })
  },
  
  // 更新回访时间
  onBackTimeChange: function(e) {
    this.setData({ 'formData.backTime': e.detail.value })
  },
  
  // 更新心理状态选择
  onMentalStatusChange: function(e) {
    this.setData({ 'formData.mentalStatus': this.data.mentalStatusOptions[e.detail.value] })
  },
  
  // 更新建议内容
  onSuggestionInput: function(e) {
    this.setData({ 'formData.suggestion': e.detail.value })
  },
  
  // 更新下次回访时间
  onNextBackTimeChange: function(e) {
    this.setData({ 'formData.nextBackTime': e.detail.value })
  },
  
  // 更新完成状态
  onFinishedChange: function(e) {
    this.setData({ 'formData.finished': e.detail.value })
  },

  // 提交回访记录
  submitBackRecord: function() {
    // 表单验证
    if (!this.data.formData.backContent.trim()) {
      wx.showToast({
        title: '请输入回访内容',
        icon: 'none'
      })
      return
    }
    
    // 验证心理状态是否已选择
    if (!this.data.formData.mentalStatus) {
      wx.showToast({
        title: '请选择心理状态',
        icon: 'none'
      })
      return
    }
    
    // 显示加载提示
    wx.showLoading({ title: '保存中' })
    
    // 获取当前登录用户信息
    const currentUserInfo = wx.getStorageSync('userInfo')
    if (!currentUserInfo) {
      wx.hideLoading()
      wx.showToast({
        title: '获取用户信息失败，请重新登录',
        icon: 'none'
      })
      return
    }
    
    // 确保有学生姓名
    const username = this.data.currentStudent.username
    
    // 准备表单数据
    const backData = {
      username: username,
      class: this.data.currentStudent.class,
      staffId: currentUserInfo._id || currentUserInfo.openId || currentUserInfo._openid,
      backContent: this.data.formData.backContent,
      backTime: this.data.formData.backTime ? new Date(this.data.formData.backTime) : new Date(),
      mentalStatus: this.data.formData.mentalStatus,
      suggestion: this.data.formData.suggestion,
      finished: this.data.formData.finished,
      createTime: new Date(),
      updateTime: new Date()
    }
    
    // 处理下次回访时间
    if (this.data.formData.nextBackTime) {
      try {
        // 确保有效的日期格式
        const nextBackDate = new Date(this.data.formData.nextBackTime);
        if (!isNaN(nextBackDate.getTime())) {
          backData.nextBackTime = nextBackDate;
        } else {
          console.error('无效的下次回访日期:', this.data.formData.nextBackTime);
        }
      } catch (error) {
        console.error('处理下次回访日期时出错:', error);
      }
    }
    
    // 向数据库添加回访记录
    db.collection('consultation_back')
      .add({
        data: backData
      })
      .then(() => {
        // 添加成功后的处理
        wx.hideLoading()
        wx.showToast({
          title: '添加成功',
          icon: 'success'
        })
        
        // 关闭对话框并刷新数据
        this.setData({ showAddModal: false })
        this.fetchBackRecords()  // 不需要传参数
        this.fetchStudentsWithConsultation()  // 刷新学生列表
      })
      .catch(err => {
        console.error('添加回访记录失败:', err)
        wx.hideLoading()
        
        // 错误处理：如果集合不存在则提示用户再试一次
        if (err.errCode === -502005) {
          wx.showToast({
            title: '首次添加记录，请再试一次',
            icon: 'none',
            duration: 2000
          })
        } else {
          wx.showToast({
            title: '添加失败',
            icon: 'none'
          })
        }
      })
  },

  // 查看学生的咨询记录
  viewConsultationRecord: function() {
    if (!this.data.currentStudent) return
    
    // 获取当前页面栈
    const pages = getCurrentPages()
    const currentPage = pages[pages.length - 1]
    
    // 检查是否有咨询记录
    if (!this.data.currentStudent.consultationRecord) {
      wx.showToast({
        title: '暂无咨询记录',
        icon: 'none'
      })
      return
    }
    
    // 跳转到心理咨询记录详情页
    try {
      wx.navigateTo({
        url: `/pages/consultation-records/index?username=${encodeURIComponent(this.data.currentStudent.username)}`,
        fail: (err) => {
          console.error('跳转咨询记录页面失败:', err)
          wx.showToast({
            title: '页面跳转失败',
            icon: 'none'
          })
        }
      })
    } catch (err) {
      // 错误处理
      console.error('查看咨询记录失败:', err)
      wx.showToast({
        title: '操作失败',
        icon: 'none'
      })
    }
  }
}) 